home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / dev / c / minigl.lha / MiniGL / demos / bounce.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-05-26  |  7.4 KB  |  422 lines
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <mgl/gl.h>
  6.  
  7.  
  8. #include <exec/exec.h>
  9. #include <dos/dos.h>
  10. #if defined(__PPC__) || defined(__VBCC__)
  11. #include <proto/dos.h>
  12. #else
  13. #include <inline/dos.h>
  14. #endif
  15.  
  16.  
  17. #define COS(X)   cos( (X) * 3.14159/180.0 )
  18. #define SIN(X)   sin( (X) * 3.14159/180.0 )
  19.  
  20. #ifndef __PPC__
  21. extern struct IntuitionBase *IntuitionBase;
  22. extern struct GfxBase *GfxBase;
  23. extern struct DosLibrary *DOSBase;
  24. #endif
  25.  
  26. #define RED 1
  27. #define WHITE 2
  28. #define CYAN 3
  29.  
  30. #define NUMSLICE 6.0
  31.  
  32. GLboolean IndexMode = GL_FALSE;
  33. GLuint Ball;
  34. GLenum Mode;
  35. GLfloat Zrot = 0.0, Zstep = 3.0;
  36. GLfloat Xpos = 0.0, Ypos = 1.0;
  37. GLfloat Xvel = 0.2, Yvel = 0.0;
  38. GLfloat Xmin = -4.0, Xmax = 4.0;
  39. GLfloat Ymin = -2.8, Ymax = 4.0;
  40. GLfloat G = -0.05;
  41. GLfloat rot = 0.0;
  42. //GLfloat step = 0.0;
  43. GLboolean do_cage = GL_TRUE; //"bugfix!" was GL_FALSE
  44.  
  45. GLenum LockMode = MGL_LOCK_SMART;
  46.  
  47. typedef struct
  48. {
  49.     GLint command;
  50.     GLfloat p1, p2, p3;
  51. } GL_Command;
  52.  
  53. #define GLC_VERTEX 1
  54. #define GLC_COLOR  2
  55. #define GLC_BEGIN  3
  56. #define GLC_END    4
  57. #define GLC_FINISH 5
  58.  
  59. GL_Command cmd[150000];
  60. int cmdptr=0;
  61.  
  62. static GLuint make_ball(void)
  63. {
  64.     //GLuint list;
  65.     GLfloat a, b;
  66.     GLfloat da = 180.0/NUMSLICE, db = 180.0/NUMSLICE;
  67.     GLfloat radius = 1.0;
  68.     GLuint color;
  69.     GLfloat x, y, z;
  70.  
  71.     cmdptr=0;
  72.  
  73.     color = 0;
  74.  
  75.     for (a = -90.0; a + da <= 90.0; a += da)
  76.     {
  77.  
  78.         cmd[cmdptr++].command = GLC_BEGIN;
  79.  
  80.         for (b = 0.0; b <= 360.0; b += db)
  81.         {
  82.  
  83.             if (color)
  84.             {
  85.                 cmd[cmdptr].command = GLC_COLOR;
  86.                 cmd[cmdptr].p1 = 1.0;
  87.                 cmd[cmdptr].p2 = 0.0;
  88.                 cmd[cmdptr].p3 = 0.0;
  89.                 cmdptr++;
  90.             }
  91.             else
  92.             {
  93.                 cmd[cmdptr].command = GLC_COLOR;
  94.                 cmd[cmdptr].p1 = 1.0;
  95.                 cmd[cmdptr].p2 = 1.0;
  96.                 cmd[cmdptr].p3 = 1.0;
  97.                 cmdptr++;
  98.             }
  99.  
  100.             x = COS(b) * COS(a);
  101.             y = SIN(b) * COS(a);
  102.             z = SIN(a);
  103.             cmd[cmdptr].command = GLC_VERTEX;
  104.             cmd[cmdptr].p1 = x;
  105.             cmd[cmdptr].p2 = y;
  106.             cmd[cmdptr].p3 = z;
  107.             cmdptr++;
  108.  
  109.             x = radius * COS(b) * COS(a + da);
  110.             y = radius * SIN(b) * COS(a + da);
  111.             z = radius * SIN(a + da);
  112.             cmd[cmdptr].command = GLC_VERTEX;
  113.             cmd[cmdptr].p1 = x;
  114.             cmd[cmdptr].p2 = y;
  115.             cmd[cmdptr].p3 = z;
  116.             cmdptr++;
  117.  
  118.             color = 1 - color;
  119.         }
  120.         cmd[cmdptr++].command = GLC_END;
  121.     }
  122.     cmd[cmdptr++].command = GLC_FINISH;
  123.  
  124.     //return list;
  125.     return 1;
  126. }
  127.  
  128. static void drawCube(void)
  129. {
  130.     glBegin(GL_QUADS);
  131.         glColor3f(1.0, 0.0, 0.0);
  132.         glVertex3f(-1,-1,-1); glColor3f(0.5, 0.5, 0.5);
  133.         glVertex3f(-1,1,-1); glVertex3f(1,1,-1); glVertex3f(1,-1,-1);
  134.  
  135.         glColor3f(1.0, 0.5, 0.0);
  136.         glVertex3f(-1,1,-1); glColor3f(0.5, 0.5, 0.5);
  137.         glVertex3f(-1,1,1); glVertex3f(1,1,1); glVertex3f(1,1,-1);
  138.  
  139.         glColor3f(0.0, 0.0, 1.0);
  140.         glVertex3f(1,1,1); glColor3f(0.5, 0.5, 0.5);
  141.         glVertex3f(-1,1,1); glVertex3f(-1,-1,1); glVertex3f(1,-1,1);
  142.  
  143.         glColor3f(0.0, 0.0, 0.0);
  144.         glVertex3f(-1,1,1); glColor3f(0.5, 0.5, 0.5);
  145.         glVertex3f(-1,1,-1); glVertex3f(-1,-1,-1); glVertex3f(-1,-1,1);
  146.  
  147.         glColor3f(1.0, 1.0, 1.0);
  148.         glVertex3f(-1,-1,1); glColor3f(0.5, 0.5, 0.5);
  149.         glVertex3f(-1,-1,-1);
  150.         glVertex3f(1,-1,-1);
  151.         glVertex3f(1,-1,1);
  152.  
  153.     glEnd();
  154. }
  155.  
  156.  
  157. static void drawBall(void)
  158. {
  159.     int i = 0;
  160.  
  161.     while (cmd[i].command != GLC_FINISH)
  162.     {
  163.         switch(cmd[i].command)
  164.         {
  165.             case GLC_BEGIN:
  166.                 glBegin(GL_QUAD_STRIP);
  167.                 break;
  168.             case GLC_COLOR:
  169.                 glColor3f(cmd[i].p1, cmd[i].p2, cmd[i].p3);
  170.                 break;
  171.             case GLC_VERTEX:
  172.                 glVertex3f(cmd[i].p1, cmd[i].p2, cmd[i].p3);
  173.                 break;
  174.             case GLC_END:
  175.                 glEnd();
  176.                 break;
  177.         }
  178.         i++;
  179.     }
  180. }
  181.  
  182.  
  183. void reshape(int width, int height)
  184. {
  185.     float aspect = (float) width / (float) height;
  186.     glViewport(0, 0, (GLint) width, (GLint) height);
  187.     glMatrixMode(GL_PROJECTION);
  188.     glLoadIdentity();
  189.     glOrtho(-6.0 * aspect, 6.0 * aspect, -6.0, 6.0, -6.0, 6.0);
  190.     glMatrixMode(GL_MODELVIEW);
  191. }
  192.  
  193. void key(char k)
  194. {
  195.     switch (k)
  196.     {
  197.         case 27:
  198.             mglExit();
  199.             break;
  200.         case 'b':
  201.             do_cage = !do_cage;
  202.             break;
  203.     }
  204. }
  205.  
  206. static void drawCage(void)
  207. {
  208.     GLfloat xmin = Xmin - 2.0,
  209.             xmax = Xmax + 2.0,
  210.             ymin = Ymin - 2.0,
  211.             ymax = Ymax + 2.0,
  212.             zmin = -2.0,
  213.             zmax = 2.0;
  214.     GLfloat color[] = { 1.0, 0.5, 0.0, 0.5 };
  215.  
  216.     glEnable(GL_BLEND);
  217.     glColor4f(0.0, 0.5, 0.5, 0.5);
  218.  
  219.     glBegin(GL_QUADS);
  220.         glVertex2f(xmax, ymax);
  221.         glVertex2f(xmax, ymin);
  222.         glVertex2f(xmin, ymin);
  223.         glVertex2f(xmin, ymax);
  224.     glEnd();
  225.     glDisable(GL_BLEND);
  226. }
  227.  
  228. static void draw(void)
  229. {
  230.     GLfloat xmin = Xmin - 1.0,
  231.             xmax = Xmax + 1.0,
  232.             ymin = Ymin - 1.0,
  233.             ymax = Ymax + 1.0,
  234.             zmin = -2.0,
  235.             zmax = 2.0;
  236.  
  237. if (LockMode == MGL_LOCK_MANUAL) //added by surgeon
  238.     mglLockDisplay();
  239.  
  240.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  241.     glRotatef(rot, 0.0, 1.0, 0.0);
  242.  
  243.     if (do_cage == GL_TRUE) drawCage();
  244.  
  245.     glPushMatrix();
  246.     glTranslatef(Xpos, Ypos, 0.0);
  247.     glScalef(2.f, 2.f, 2.f);
  248.     glRotatef(8.0, 0.0, 0.0, 1.0);
  249.     glRotatef(90.0, 1.0, 0.0, 0.0);
  250.     glRotatef(Zrot, 0.0, 0.0, 1.0);
  251.  
  252.     drawBall();
  253.  
  254.  
  255.     glPopMatrix();
  256.  
  257.     glFrontFace(GL_CCW);
  258.     if (do_cage == GL_TRUE) drawCage();
  259.     glFrontFace(GL_CW);
  260.  
  261.     glFlush();
  262.  
  263. if (LockMode == MGL_LOCK_MANUAL) //added by surgeon
  264.     mglUnlockDisplay();
  265.     mglSwitchDisplay();
  266. }
  267.  
  268.  
  269. static void idle(void)
  270. {
  271.     static float vel0 = -100.0;
  272.  
  273. //    step += rot;
  274. //    step = fmod(step,180.0);
  275.  
  276.     Zrot += fabs(Zstep);
  277.  
  278.     Xpos += Xvel;
  279.     if (Xpos >= Xmax)
  280.     {
  281.         Xpos = Xmax;
  282.         Xvel = -Xvel;
  283.         Zstep = -Zstep;
  284.     }
  285.     if (Xpos <= Xmin)
  286.     {
  287.         Xpos = Xmin;
  288.         Xvel = -Xvel;
  289.         Zstep = -Zstep;
  290.     }
  291.     Ypos += Yvel;
  292.     Yvel += G;
  293.     if (Ypos < Ymin)
  294.     {
  295.         Ypos = Ymin;
  296.         if (vel0 == -100.0)
  297.         {
  298.             vel0 = fabs(Yvel);
  299.         }
  300.         Yvel = vel0;
  301.     }
  302.     draw();
  303. }
  304.  
  305. GLboolean culling = GL_TRUE;
  306.  
  307. int main(int argc, char *argv[])
  308. {
  309.     GLint width=320; GLint height=240;
  310.     int i;
  311.     ULONG ModeID = INVALID_ID;
  312.  
  313.     for (i=1; i<argc; i++)
  314.     {
  315.         if (0 == stricmp(argv[i], "-modeid"))
  316.         {
  317.             i++;
  318.             ModeID = atoi(argv[i]);
  319.         }
  320.         if (0 == stricmp(argv[i], "-width"))
  321.         {
  322.             i++;
  323.             width = atoi(argv[i]);
  324.         }
  325.         if (0 == stricmp(argv[i], "-height"))
  326.         {
  327.             i++;
  328.             height = atoi(argv[i]);
  329.         }
  330.         if (0 == stricmp(argv[i],"-xmin"))
  331.         {
  332.             i++;
  333.             Xmin = atof(argv[i]);
  334.         }
  335.         if (0 == stricmp(argv[i],"-xmax"))
  336.         {
  337.             i++;
  338.             Xmax = atof(argv[i]);
  339.         }
  340.         if (0 == stricmp(argv[i],"-rot"))
  341.         {
  342.             i++;
  343.             rot = atof(argv[i]);
  344.         }
  345.         if (0 == stricmp(argv[i],"-nocull"))
  346.         {
  347.             culling = GL_FALSE;
  348.         }
  349.         if (0 == stricmp(argv[i],"-noback"))
  350.         {
  351.             do_cage = GL_FALSE;
  352.         }
  353.         if (0 == stricmp(argv[i],"-window"))
  354.         {
  355.             mglChooseWindowMode(GL_TRUE);
  356.         }
  357.  
  358.       if (0 == strcmp(argv[i], "-lock"))
  359.         {
  360.             i++;
  361.             if (0 == stricmp(argv[i], "manual"))
  362.             {
  363.                 LockMode = MGL_LOCK_MANUAL;
  364.             }
  365.             else if (0 == stricmp(argv[i], "auto"))
  366.             {
  367.                 LockMode = MGL_LOCK_AUTOMATIC;
  368.             }
  369.             else if (0 == stricmp(argv[i], "smart"))
  370.             {
  371.                 LockMode = MGL_LOCK_SMART;
  372.             }
  373.             else printf("Unknown lockmode. Using default\n");
  374.       }
  375.  
  376.     }
  377.  
  378.     mglChooseVertexBufferSize(1000);
  379.     mglChooseNumberOfBuffers(3);
  380.     MGLInit();
  381.  
  382.     if (ModeID == INVALID_ID)
  383.     {
  384.         mglCreateContext(0,0,width,height);
  385.     }
  386.     else
  387.     {
  388.         mglCreateContextFromID(ModeID, &width, &height);
  389.         printf("Screen mode is %d×%d\n", width, height);
  390.     }
  391.  
  392.  
  393.     mglEnableSync(GL_TRUE);
  394.  
  395.     glClearColor(0.0, 0.0, 0.0, 1.0);
  396.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  397.  
  398.     Ball = make_ball();
  399.  
  400.     glCullFace(GL_BACK);
  401.     if (culling == GL_TRUE)
  402.     {
  403.         glEnable(GL_CULL_FACE);
  404.     }
  405.     else
  406.     {
  407.         glDisable(GL_CULL_FACE);
  408.     }
  409.  
  410.     glDisable(GL_DEPTH_TEST);
  411.     glShadeModel(GL_FLAT);
  412.  
  413.     reshape(width,height);
  414.     mglLockMode(LockMode);
  415.     mglIdleFunc(idle);
  416.     mglKeyFunc(key);
  417.     mglMainLoop();
  418.     mglDeleteContext();
  419.     MGLTerm();
  420.     return 0;             /* ANSI C requires main to return int. */
  421. }
  422.